package com.atguigu.tingshu.album.service.impl;

import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.service.AlbumAttributeValueService;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.common.constant.KafkaConstant;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.execption.GuiguException;
import com.atguigu.tingshu.common.result.ResultCodeEnum;
import com.atguigu.tingshu.common.service.KafkaService;
import com.atguigu.tingshu.common.util.AuthContextHolder;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.AlbumAttributeValueVo;
import com.atguigu.tingshu.vo.album.AlbumInfoVo;
import com.atguigu.tingshu.vo.album.AlbumListVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import net.sf.jsqlparser.expression.AllValue;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.beans.Transient;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

	@Autowired
	private AlbumInfoMapper albumInfoMapper;

	@Autowired
	private AlbumAttributeValueMapper albumAttributeValueMapper;

	@Autowired
	private AlbumStatMapper albumStatMapper;

	@Autowired
	private AlbumAttributeValueService albumAttributeValueService;

	@Autowired
	private KafkaService kafkaService;




	/**
	 * 保存专辑
	 * @param albumInfo
	 * @return
	 */
	@Override
	@Transactional(rollbackFor = Exception.class  )
	public void saveAlbumInfo(AlbumInfoVo albumInfoVo) {
		//创建对象插入数据
		AlbumInfo albumInfo = new AlbumInfo();
		BeanUtils.copyProperties(albumInfoVo, albumInfo);
		//设置用户id
		Long userId = AuthContextHolder.getUserId();
		if (null == userId){
			throw new GuiguException(ResultCodeEnum.LOGIN_AUTH);
		}
		albumInfo.setUserId(userId);
		//设置状态
		albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
		//设置免费集数,如果不免费执行
		if (!SystemConstant.ALBUM_PAY_TYPE_FREE.equals(albumInfo.getPayType())){
			albumInfo.setTracksForFree(5);
		}
		//插入专辑
		albumInfoMapper.insert(albumInfo);

		//获取属性集合插入数据
		List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
		if (!CollectionUtils.isEmpty(albumAttributeValueVoList)){
			albumAttributeValueVoList.forEach(albumAttributeValueVo -> {
				AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
				BeanUtils.copyProperties(albumAttributeValueVo,albumAttributeValue);
				albumAttributeValue.setAlbumId(albumInfo.getId());
				albumAttributeValueMapper.insert(albumAttributeValue);
			});
		}

		//专辑统计表
		this.saveAlbumStat(albumInfo.getId(),SystemConstant.ALBUM_STAT_PLAY);
		this.saveAlbumStat(albumInfo.getId(),SystemConstant.ALBUM_STAT_SUBSCRIBE);
		this.saveAlbumStat(albumInfo.getId(),SystemConstant.ALBUM_STAT_BUY);
		this.saveAlbumStat(albumInfo.getId(),SystemConstant.ALBUM_STAT_COMMENT);

		//判断是否需要上架
		if ("1".equals(albumInfoVo.getIsOpen())){
			kafkaService.sendMsg(KafkaConstant.QUEUE_ALBUM_UPPER,albumInfo.getId().toString());
		}
	}

	/**
	 * 分页查询专辑列表
	 * @param albumListVoPage
	 * @param albumInfoQuery
	 * @return
	 */
	@Override
	public IPage<AlbumListVo> findUserSubscribePage(Page<AlbumListVo> albumListVoPage, AlbumInfoQuery albumInfoQuery) {
		//获取用户id
		Long userId = AuthContextHolder.getUserId();
		if (null == userId){
			throw new GuiguException(ResultCodeEnum.LOGIN_AUTH);
		}
		albumInfoQuery.setUserId(userId);
		//调用mapper查询
		IPage<AlbumListVo> albumListVoIPage = this.albumInfoMapper.selectUserSubscribePage(albumListVoPage,albumInfoQuery);
		return albumListVoIPage;
	}

	/**
	 * 删除专辑
	 * @param albumId
	 */
	@Override
	@Transactional(rollbackFor = Exception.class)
	public void removeAlbumInfo(Long albumId) {
		//删除专辑信息
		boolean b = this.removeById(albumId);
		System.out.println(b);
		//删除专辑标签信息
		albumAttributeValueMapper.delete(
				new LambdaQueryWrapper<AlbumAttributeValue>()
						.eq(AlbumAttributeValue::getAlbumId,albumId));
		//删除专辑统计
		albumStatMapper.delete(
				new LambdaQueryWrapper<AlbumStat>()
						.eq(AlbumStat::getAlbumId,albumId));

		kafkaService.sendMsg(KafkaConstant.QUEUE_ALBUM_LOWER,albumId.toString());
	}

	/**
	 * 回显专辑
	 * @param albumId
	 * @return
	 */
	@Override
	public AlbumInfoVo getAlbumInfo(Long albumId) {
		AlbumInfoVo albumInfoVo = new AlbumInfoVo();
		//查询专辑信息
		AlbumInfo albumInfo = this.getById(albumId);
		if (albumId == null){
			throw new GuiguException(ResultCodeEnum.DATA_ERROR);
		}
		BeanUtils.copyProperties(albumInfo,albumInfoVo);
		//查询专辑属性
		List<AlbumAttributeValue> albumAttributeValueList = albumAttributeValueMapper.selectList(
				new LambdaQueryWrapper<AlbumAttributeValue>()
						.eq(AlbumAttributeValue::getAlbumId, albumId));
		//复制专辑属性vo
		List<AlbumAttributeValueVo> albumAttributeValueVoList = new ArrayList<>();
		albumAttributeValueList.forEach(albumAttributeValue -> {
			AlbumAttributeValueVo albumAttributeValueVo = new AlbumAttributeValueVo();
			BeanUtils.copyProperties(albumAttributeValue,albumAttributeValueVo);
			albumAttributeValueVoList.add(albumAttributeValueVo);
		});

		//封装数据
		albumInfoVo.setAlbumAttributeValueVoList(albumAttributeValueVoList);

		return albumInfoVo;
	}

	/**
	 *  修改保存专辑
	 * @param albumId
	 * @param albumInfoVo
	 */
	@Override
	@Transactional
	public void updateAlbumInfo(Long albumId,AlbumInfoVo albumInfoVo) {
		AlbumInfo albumInfo = this.getById(albumId);
		BeanUtils.copyProperties(albumInfoVo,albumInfo);
		this.updateById(albumInfo);
		List<AlbumAttributeValue> albumAttributeValueList = albumInfo.getAlbumAttributeValueVoList();
		albumAttributeValueMapper
				.delete(new LambdaQueryWrapper<AlbumAttributeValue>()
						.eq(AlbumAttributeValue::getAlbumId,albumId));

		if (CollectionUtils.isEmpty(albumAttributeValueList)){
			List<AlbumAttributeValue> albumAttributeValues = albumAttributeValueList.stream().map(attributeValueVo -> {
				AlbumAttributeValue attributeValue = new AlbumAttributeValue();
				attributeValue.setAlbumId(albumId);
				BeanUtils.copyProperties(attributeValueVo, attributeValue);
				return attributeValue;
			}).collect(Collectors.toList());
			this.albumAttributeValueService.saveBatch(albumAttributeValues);
		}
		this.updateById(albumInfo);

		if ("1".equals(albumInfoVo.getIsOpen())){
			kafkaService.sendMsg(KafkaConstant.QUEUE_ALBUM_UPPER,albumInfo.getId().toString());
		} else {
			kafkaService.sendMsg(KafkaConstant.QUEUE_ALBUM_LOWER,albumInfo.getId().toString());
		}
	}

	@Override
	public List<AlbumInfo> findUserAllAlbumList() {
		//获取用户id
		Long userId = AuthContextHolder.getUserId();
		if (null == userId){
			throw new GuiguException(ResultCodeEnum.LOGIN_AUTH);
		}
		//查询数据
		Page<AlbumInfo> albumInfoPage = new Page<>(1, 50);
		Page<AlbumInfo> page = this.lambdaQuery()
				.eq(AlbumInfo::getUserId, userId)
				.eq(AlbumInfo::getIsDeleted, 0)
				.orderByDesc(AlbumInfo::getId)
				.page(albumInfoPage);
		List<AlbumInfo> records = page.getRecords();
		return records;
	}

	/**
	 * 获取专辑属性值列表
	 * @param albumId
	 * @return
	 */
	@Override
	public List<AlbumAttributeValue> findAlbumAttributeValue(Long albumId) {
		List<AlbumAttributeValue> list = albumAttributeValueService.lambdaQuery()
				.eq(AlbumAttributeValue::getAlbumId, albumId)
				.list();
		if (CollectionUtils.isEmpty(list)){
			return Collections.emptyList();
		}
		return list;
	}

	//统计数据
	private void saveAlbumStat(Long albumInfoId, String statType) {
		AlbumStat albumStat = new AlbumStat();
		albumStat.setAlbumId(albumInfoId);
		albumStat.setStatType(statType);
		albumStat.setStatNum(0);
		albumStatMapper.insert(albumStat);
	}
}
